home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / mozilla-firefox / include / gfx / gfxIImageFrame.h < prev    next >
C/C++ Source or Header  |  2006-05-08  |  20KB  |  502 lines
  1. /*
  2.  * DO NOT EDIT.  THIS FILE IS GENERATED FROM gfxIImageFrame.idl
  3.  */
  4.  
  5. #ifndef __gen_gfxIImageFrame_h__
  6. #define __gen_gfxIImageFrame_h__
  7.  
  8.  
  9. #ifndef __gen_nsISupports_h__
  10. #include "nsISupports.h"
  11. #endif
  12.  
  13. #ifndef __gen_gfxtypes_h__
  14. #include "gfxtypes.h"
  15. #endif
  16.  
  17. #ifndef __gen_gfxIFormats_h__
  18. #include "gfxIFormats.h"
  19. #endif
  20.  
  21. /* For IDL files that don't want to include root IDL files. */
  22. #ifndef NS_NO_VTABLE
  23. #define NS_NO_VTABLE
  24. #endif
  25. #include "nsRect.h"
  26.  
  27. /* starting interface:    gfxIImageFrame */
  28. #define GFXIIMAGEFRAME_IID_STR "f6d00ee7-defc-4101-b2dc-e72cf4c37c3c"
  29.  
  30. #define GFXIIMAGEFRAME_IID \
  31.   {0xf6d00ee7, 0xdefc, 0x4101, \
  32.     { 0xb2, 0xdc, 0xe7, 0x2c, 0xf4, 0xc3, 0x7c, 0x3c }}
  33.  
  34. /**
  35.  * gfxIImageFrame interface
  36.  *
  37.  * All x, y, width, height values are in pixels.
  38.  *
  39.  * @author Tim Rowley <tor@cs.brown.edu>
  40.  * @author Stuart Parmenter <pavlov@netscape.com>
  41.  * @version 0.1
  42.  */
  43. class NS_NO_VTABLE gfxIImageFrame : public nsISupports {
  44.  public: 
  45.  
  46.   NS_DEFINE_STATIC_IID_ACCESSOR(GFXIIMAGEFRAME_IID)
  47.  
  48.   /**
  49.    * Create a new \a aWidth x \a aHeight sized image.
  50.    *
  51.    * @param aX The x-offset from the origin of the gfxIImageContainer parent.
  52.    * @param aY The y-offset from the origin of the gfxIImageContainer parent.
  53.    * @param aWidth The width of the image to create.
  54.    * @param aHeight The height of the image to create.
  55.    * @param aFormat the width of the image to create.
  56.    *
  57.    * @note The data of a new image is unspecified (Whats the word i'm looking for here?).
  58.    */
  59.   /* void init (in PRInt32 aX, in PRInt32 aY, in PRInt32 aWidth, in PRInt32 aHeight, in gfx_format aFormat, in gfx_depth aDepth); */
  60.   NS_IMETHOD Init(PRInt32 aX, PRInt32 aY, PRInt32 aWidth, PRInt32 aHeight, gfx_format aFormat, gfx_depth aDepth) = 0;
  61.  
  62.   /**
  63.    * TRUE by default.  When set to FALSE, you will no longer be able to make any modifications
  64.    * to the data of the image.  Any attempts will fail.
  65.    */
  66.   /* attribute boolean mutable; */
  67.   NS_IMETHOD GetMutable(PRBool *aMutable) = 0;
  68.   NS_IMETHOD SetMutable(PRBool aMutable) = 0;
  69.  
  70.   /**
  71.    * The x-offset of the image.
  72.    */
  73.   /* readonly attribute PRInt32 x; */
  74.   NS_IMETHOD GetX(PRInt32 *aX) = 0;
  75.  
  76.   /**
  77.    * The y-offset of the image.
  78.    */
  79.   /* readonly attribute PRInt32 y; */
  80.   NS_IMETHOD GetY(PRInt32 *aY) = 0;
  81.  
  82.   /**
  83.    * The width of the image.
  84.    */
  85.   /* readonly attribute PRInt32 width; */
  86.   NS_IMETHOD GetWidth(PRInt32 *aWidth) = 0;
  87.  
  88.   /**
  89.    * The height of the image.
  90.    */
  91.   /* readonly attribute PRInt32 height; */
  92.   NS_IMETHOD GetHeight(PRInt32 *aHeight) = 0;
  93.  
  94.   /**
  95.    * The rectangle this frame ocupies.
  96.    * @param rect this is really an out parameter.
  97.    */
  98.   /* [noscript] void getRect (in nsRectRef rect); */
  99.   NS_IMETHOD GetRect(nsIntRect & rect) = 0;
  100.  
  101.   /**
  102.    * The image data format the image was created with.
  103.    * @see gfxIFormats
  104.    */
  105.   /* readonly attribute gfx_format format; */
  106.   NS_IMETHOD GetFormat(gfx_format *aFormat) = 0;
  107.  
  108.   /**
  109.    * returns whether the image requires the background to be painted
  110.    */
  111.   /* readonly attribute boolean needsBackground; */
  112.   NS_IMETHOD GetNeedsBackground(PRBool *aNeedsBackground) = 0;
  113.  
  114.   /* readonly attribute unsigned long imageBytesPerRow; */
  115.   NS_IMETHOD GetImageBytesPerRow(PRUint32 *aImageBytesPerRow) = 0;
  116.  
  117.   /**
  118.    * returns the number of bytes allocated for the image
  119.    */
  120.   /* readonly attribute unsigned long imageDataLength; */
  121.   NS_IMETHOD GetImageDataLength(PRUint32 *aImageDataLength) = 0;
  122.  
  123.   /* void getImageData ([array, size_is (length)] out PRUint8 bits, out unsigned long length); */
  124.   NS_IMETHOD GetImageData(PRUint8 **bits, PRUint32 *length) = 0;
  125.  
  126.   /**
  127.    * Sets \a length bytes of \a data in this object.
  128.    * @param offset The offset from the first pixel in bytes.  To set
  129.    *   data beginning with the first (top left) pixel in the image, \a offset
  130.    *   should be 0; to set data beginning with, for example, the sixth pixel in
  131.    *   the first row of a RGBA32 image, the offset should be 20.
  132.    * @attension should we use PRUint32 instead?
  133.    */
  134.   /* void setImageData ([array, size_is (length), const] in PRUint8 data, in unsigned long length, in long offset); */
  135.   NS_IMETHOD SetImageData(const PRUint8 *data, PRUint32 length, PRInt32 offset) = 0;
  136.  
  137.   /**
  138.    * Lock image pixels before addressing the data directly
  139.    */
  140.   /* void lockImageData (); */
  141.   NS_IMETHOD LockImageData(void) = 0;
  142.  
  143.   /**
  144.    * Unlock image pixels
  145.    */
  146.   /* void unlockImageData (); */
  147.   NS_IMETHOD UnlockImageData(void) = 0;
  148.  
  149.   /* readonly attribute unsigned long alphaBytesPerRow; */
  150.   NS_IMETHOD GetAlphaBytesPerRow(PRUint32 *aAlphaBytesPerRow) = 0;
  151.  
  152.   /**
  153.    * returns the number of bytes allocated for the alpha mask
  154.    */
  155.   /* readonly attribute unsigned long alphaDataLength; */
  156.   NS_IMETHOD GetAlphaDataLength(PRUint32 *aAlphaDataLength) = 0;
  157.  
  158.   /* void getAlphaData ([array, size_is (length)] out PRUint8 bits, out unsigned long length); */
  159.   NS_IMETHOD GetAlphaData(PRUint8 **bits, PRUint32 *length) = 0;
  160.  
  161.   /**
  162.    * Sets \a length bytes of \a data in this object.
  163.    */
  164.   /* void setAlphaData ([array, size_is (length), const] in PRUint8 data, in unsigned long length, in long offset); */
  165.   NS_IMETHOD SetAlphaData(const PRUint8 *data, PRUint32 length, PRInt32 offset) = 0;
  166.  
  167.   /**
  168.    * Lock alpha pixels before addressing the data directly
  169.    */
  170.   /* void lockAlphaData (); */
  171.   NS_IMETHOD LockAlphaData(void) = 0;
  172.  
  173.   /**
  174.    * Unlock alpha pixels
  175.    */
  176.   /* void unlockAlphaData (); */
  177.   NS_IMETHOD UnlockAlphaData(void) = 0;
  178.  
  179.   /**
  180.    * Blit this frame into another frame. Used for GIF animation compositing
  181.    */
  182.   /* void drawTo (in gfxIImageFrame aDst, in PRInt32 aDX, in PRInt32 aDY, in PRInt32 aDWidth, in PRInt32 aDHeight); */
  183.   NS_IMETHOD DrawTo(gfxIImageFrame *aDst, PRInt32 aDX, PRInt32 aDY, PRInt32 aDWidth, PRInt32 aDHeight) = 0;
  184.  
  185.   /**
  186.    * Represents the number of milliseconds until the next frame should be displayed.
  187.    * @note -1 means that this frame should be displayed forever.
  188.    */
  189.   /* attribute long timeout; */
  190.   NS_IMETHOD GetTimeout(PRInt32 *aTimeout) = 0;
  191.   NS_IMETHOD SetTimeout(PRInt32 aTimeout) = 0;
  192.  
  193.   /* attribute long frameDisposalMethod; */
  194.   NS_IMETHOD GetFrameDisposalMethod(PRInt32 *aFrameDisposalMethod) = 0;
  195.   NS_IMETHOD SetFrameDisposalMethod(PRInt32 aFrameDisposalMethod) = 0;
  196.  
  197.   /* attribute gfx_color backgroundColor; */
  198.   NS_IMETHOD GetBackgroundColor(gfx_color *aBackgroundColor) = 0;
  199.   NS_IMETHOD SetBackgroundColor(gfx_color aBackgroundColor) = 0;
  200.  
  201. };
  202.  
  203. /* Use this macro when declaring classes that implement this interface. */
  204. #define NS_DECL_GFXIIMAGEFRAME \
  205.   NS_IMETHOD Init(PRInt32 aX, PRInt32 aY, PRInt32 aWidth, PRInt32 aHeight, gfx_format aFormat, gfx_depth aDepth); \
  206.   NS_IMETHOD GetMutable(PRBool *aMutable); \
  207.   NS_IMETHOD SetMutable(PRBool aMutable); \
  208.   NS_IMETHOD GetX(PRInt32 *aX); \
  209.   NS_IMETHOD GetY(PRInt32 *aY); \
  210.   NS_IMETHOD GetWidth(PRInt32 *aWidth); \
  211.   NS_IMETHOD GetHeight(PRInt32 *aHeight); \
  212.   NS_IMETHOD GetRect(nsIntRect & rect); \
  213.   NS_IMETHOD GetFormat(gfx_format *aFormat); \
  214.   NS_IMETHOD GetNeedsBackground(PRBool *aNeedsBackground); \
  215.   NS_IMETHOD GetImageBytesPerRow(PRUint32 *aImageBytesPerRow); \
  216.   NS_IMETHOD GetImageDataLength(PRUint32 *aImageDataLength); \
  217.   NS_IMETHOD GetImageData(PRUint8 **bits, PRUint32 *length); \
  218.   NS_IMETHOD SetImageData(const PRUint8 *data, PRUint32 length, PRInt32 offset); \
  219.   NS_IMETHOD LockImageData(void); \
  220.   NS_IMETHOD UnlockImageData(void); \
  221.   NS_IMETHOD GetAlphaBytesPerRow(PRUint32 *aAlphaBytesPerRow); \
  222.   NS_IMETHOD GetAlphaDataLength(PRUint32 *aAlphaDataLength); \
  223.   NS_IMETHOD GetAlphaData(PRUint8 **bits, PRUint32 *length); \
  224.   NS_IMETHOD SetAlphaData(const PRUint8 *data, PRUint32 length, PRInt32 offset); \
  225.   NS_IMETHOD LockAlphaData(void); \
  226.   NS_IMETHOD UnlockAlphaData(void); \
  227.   NS_IMETHOD DrawTo(gfxIImageFrame *aDst, PRInt32 aDX, PRInt32 aDY, PRInt32 aDWidth, PRInt32 aDHeight); \
  228.   NS_IMETHOD GetTimeout(PRInt32 *aTimeout); \
  229.   NS_IMETHOD SetTimeout(PRInt32 aTimeout); \
  230.   NS_IMETHOD GetFrameDisposalMethod(PRInt32 *aFrameDisposalMethod); \
  231.   NS_IMETHOD SetFrameDisposalMethod(PRInt32 aFrameDisposalMethod); \
  232.   NS_IMETHOD GetBackgroundColor(gfx_color *aBackgroundColor); \
  233.   NS_IMETHOD SetBackgroundColor(gfx_color aBackgroundColor); 
  234.  
  235. /* Use this macro to declare functions that forward the behavior of this interface to another object. */
  236. #define NS_FORWARD_GFXIIMAGEFRAME(_to) \
  237.   NS_IMETHOD Init(PRInt32 aX, PRInt32 aY, PRInt32 aWidth, PRInt32 aHeight, gfx_format aFormat, gfx_depth aDepth) { return _to Init(aX, aY, aWidth, aHeight, aFormat, aDepth); } \
  238.   NS_IMETHOD GetMutable(PRBool *aMutable) { return _to GetMutable(aMutable); } \
  239.   NS_IMETHOD SetMutable(PRBool aMutable) { return _to SetMutable(aMutable); } \
  240.   NS_IMETHOD GetX(PRInt32 *aX) { return _to GetX(aX); } \
  241.   NS_IMETHOD GetY(PRInt32 *aY) { return _to GetY(aY); } \
  242.   NS_IMETHOD GetWidth(PRInt32 *aWidth) { return _to GetWidth(aWidth); } \
  243.   NS_IMETHOD GetHeight(PRInt32 *aHeight) { return _to GetHeight(aHeight); } \
  244.   NS_IMETHOD GetRect(nsIntRect & rect) { return _to GetRect(rect); } \
  245.   NS_IMETHOD GetFormat(gfx_format *aFormat) { return _to GetFormat(aFormat); } \
  246.   NS_IMETHOD GetNeedsBackground(PRBool *aNeedsBackground) { return _to GetNeedsBackground(aNeedsBackground); } \
  247.   NS_IMETHOD GetImageBytesPerRow(PRUint32 *aImageBytesPerRow) { return _to GetImageBytesPerRow(aImageBytesPerRow); } \
  248.   NS_IMETHOD GetImageDataLength(PRUint32 *aImageDataLength) { return _to GetImageDataLength(aImageDataLength); } \
  249.   NS_IMETHOD GetImageData(PRUint8 **bits, PRUint32 *length) { return _to GetImageData(bits, length); } \
  250.   NS_IMETHOD SetImageData(const PRUint8 *data, PRUint32 length, PRInt32 offset) { return _to SetImageData(data, length, offset); } \
  251.   NS_IMETHOD LockImageData(void) { return _to LockImageData(); } \
  252.   NS_IMETHOD UnlockImageData(void) { return _to UnlockImageData(); } \
  253.   NS_IMETHOD GetAlphaBytesPerRow(PRUint32 *aAlphaBytesPerRow) { return _to GetAlphaBytesPerRow(aAlphaBytesPerRow); } \
  254.   NS_IMETHOD GetAlphaDataLength(PRUint32 *aAlphaDataLength) { return _to GetAlphaDataLength(aAlphaDataLength); } \
  255.   NS_IMETHOD GetAlphaData(PRUint8 **bits, PRUint32 *length) { return _to GetAlphaData(bits, length); } \
  256.   NS_IMETHOD SetAlphaData(const PRUint8 *data, PRUint32 length, PRInt32 offset) { return _to SetAlphaData(data, length, offset); } \
  257.   NS_IMETHOD LockAlphaData(void) { return _to LockAlphaData(); } \
  258.   NS_IMETHOD UnlockAlphaData(void) { return _to UnlockAlphaData(); } \
  259.   NS_IMETHOD DrawTo(gfxIImageFrame *aDst, PRInt32 aDX, PRInt32 aDY, PRInt32 aDWidth, PRInt32 aDHeight) { return _to DrawTo(aDst, aDX, aDY, aDWidth, aDHeight); } \
  260.   NS_IMETHOD GetTimeout(PRInt32 *aTimeout) { return _to GetTimeout(aTimeout); } \
  261.   NS_IMETHOD SetTimeout(PRInt32 aTimeout) { return _to SetTimeout(aTimeout); } \
  262.   NS_IMETHOD GetFrameDisposalMethod(PRInt32 *aFrameDisposalMethod) { return _to GetFrameDisposalMethod(aFrameDisposalMethod); } \
  263.   NS_IMETHOD SetFrameDisposalMethod(PRInt32 aFrameDisposalMethod) { return _to SetFrameDisposalMethod(aFrameDisposalMethod); } \
  264.   NS_IMETHOD GetBackgroundColor(gfx_color *aBackgroundColor) { return _to GetBackgroundColor(aBackgroundColor); } \
  265.   NS_IMETHOD SetBackgroundColor(gfx_color aBackgroundColor) { return _to SetBackgroundColor(aBackgroundColor); } 
  266.  
  267. /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
  268. #define NS_FORWARD_SAFE_GFXIIMAGEFRAME(_to) \
  269.   NS_IMETHOD Init(PRInt32 aX, PRInt32 aY, PRInt32 aWidth, PRInt32 aHeight, gfx_format aFormat, gfx_depth aDepth) { return !_to ? NS_ERROR_NULL_POINTER : _to->Init(aX, aY, aWidth, aHeight, aFormat, aDepth); } \
  270.   NS_IMETHOD GetMutable(PRBool *aMutable) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetMutable(aMutable); } \
  271.   NS_IMETHOD SetMutable(PRBool aMutable) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetMutable(aMutable); } \
  272.   NS_IMETHOD GetX(PRInt32 *aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetX(aX); } \
  273.   NS_IMETHOD GetY(PRInt32 *aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetY(aY); } \
  274.   NS_IMETHOD GetWidth(PRInt32 *aWidth) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetWidth(aWidth); } \
  275.   NS_IMETHOD GetHeight(PRInt32 *aHeight) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetHeight(aHeight); } \
  276.   NS_IMETHOD GetRect(nsIntRect & rect) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetRect(rect); } \
  277.   NS_IMETHOD GetFormat(gfx_format *aFormat) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetFormat(aFormat); } \
  278.   NS_IMETHOD GetNeedsBackground(PRBool *aNeedsBackground) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetNeedsBackground(aNeedsBackground); } \
  279.   NS_IMETHOD GetImageBytesPerRow(PRUint32 *aImageBytesPerRow) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetImageBytesPerRow(aImageBytesPerRow); } \
  280.   NS_IMETHOD GetImageDataLength(PRUint32 *aImageDataLength) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetImageDataLength(aImageDataLength); } \
  281.   NS_IMETHOD GetImageData(PRUint8 **bits, PRUint32 *length) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetImageData(bits, length); } \
  282.   NS_IMETHOD SetImageData(const PRUint8 *data, PRUint32 length, PRInt32 offset) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetImageData(data, length, offset); } \
  283.   NS_IMETHOD LockImageData(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->LockImageData(); } \
  284.   NS_IMETHOD UnlockImageData(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->UnlockImageData(); } \
  285.   NS_IMETHOD GetAlphaBytesPerRow(PRUint32 *aAlphaBytesPerRow) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetAlphaBytesPerRow(aAlphaBytesPerRow); } \
  286.   NS_IMETHOD GetAlphaDataLength(PRUint32 *aAlphaDataLength) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetAlphaDataLength(aAlphaDataLength); } \
  287.   NS_IMETHOD GetAlphaData(PRUint8 **bits, PRUint32 *length) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetAlphaData(bits, length); } \
  288.   NS_IMETHOD SetAlphaData(const PRUint8 *data, PRUint32 length, PRInt32 offset) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetAlphaData(data, length, offset); } \
  289.   NS_IMETHOD LockAlphaData(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->LockAlphaData(); } \
  290.   NS_IMETHOD UnlockAlphaData(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->UnlockAlphaData(); } \
  291.   NS_IMETHOD DrawTo(gfxIImageFrame *aDst, PRInt32 aDX, PRInt32 aDY, PRInt32 aDWidth, PRInt32 aDHeight) { return !_to ? NS_ERROR_NULL_POINTER : _to->DrawTo(aDst, aDX, aDY, aDWidth, aDHeight); } \
  292.   NS_IMETHOD GetTimeout(PRInt32 *aTimeout) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetTimeout(aTimeout); } \
  293.   NS_IMETHOD SetTimeout(PRInt32 aTimeout) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetTimeout(aTimeout); } \
  294.   NS_IMETHOD GetFrameDisposalMethod(PRInt32 *aFrameDisposalMethod) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetFrameDisposalMethod(aFrameDisposalMethod); } \
  295.   NS_IMETHOD SetFrameDisposalMethod(PRInt32 aFrameDisposalMethod) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetFrameDisposalMethod(aFrameDisposalMethod); } \
  296.   NS_IMETHOD GetBackgroundColor(gfx_color *aBackgroundColor) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetBackgroundColor(aBackgroundColor); } \
  297.   NS_IMETHOD SetBackgroundColor(gfx_color aBackgroundColor) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetBackgroundColor(aBackgroundColor); } 
  298.  
  299. #if 0
  300. /* Use the code below as a template for the implementation class for this interface. */
  301.  
  302. /* Header file */
  303. class _MYCLASS_ : public gfxIImageFrame
  304. {
  305. public:
  306.   NS_DECL_ISUPPORTS
  307.   NS_DECL_GFXIIMAGEFRAME
  308.  
  309.   _MYCLASS_();
  310.  
  311. private:
  312.   ~_MYCLASS_();
  313.  
  314. protected:
  315.   /* additional members */
  316. };
  317.  
  318. /* Implementation file */
  319. NS_IMPL_ISUPPORTS1(_MYCLASS_, gfxIImageFrame)
  320.  
  321. _MYCLASS_::_MYCLASS_()
  322. {
  323.   /* member initializers and constructor code */
  324. }
  325.  
  326. _MYCLASS_::~_MYCLASS_()
  327. {
  328.   /* destructor code */
  329. }
  330.  
  331. /* void init (in PRInt32 aX, in PRInt32 aY, in PRInt32 aWidth, in PRInt32 aHeight, in gfx_format aFormat, in gfx_depth aDepth); */
  332. NS_IMETHODIMP _MYCLASS_::Init(PRInt32 aX, PRInt32 aY, PRInt32 aWidth, PRInt32 aHeight, gfx_format aFormat, gfx_depth aDepth)
  333. {
  334.     return NS_ERROR_NOT_IMPLEMENTED;
  335. }
  336.  
  337. /* attribute boolean mutable; */
  338. NS_IMETHODIMP _MYCLASS_::GetMutable(PRBool *aMutable)
  339. {
  340.     return NS_ERROR_NOT_IMPLEMENTED;
  341. }
  342. NS_IMETHODIMP _MYCLASS_::SetMutable(PRBool aMutable)
  343. {
  344.     return NS_ERROR_NOT_IMPLEMENTED;
  345. }
  346.  
  347. /* readonly attribute PRInt32 x; */
  348. NS_IMETHODIMP _MYCLASS_::GetX(PRInt32 *aX)
  349. {
  350.     return NS_ERROR_NOT_IMPLEMENTED;
  351. }
  352.  
  353. /* readonly attribute PRInt32 y; */
  354. NS_IMETHODIMP _MYCLASS_::GetY(PRInt32 *aY)
  355. {
  356.     return NS_ERROR_NOT_IMPLEMENTED;
  357. }
  358.  
  359. /* readonly attribute PRInt32 width; */
  360. NS_IMETHODIMP _MYCLASS_::GetWidth(PRInt32 *aWidth)
  361. {
  362.     return NS_ERROR_NOT_IMPLEMENTED;
  363. }
  364.  
  365. /* readonly attribute PRInt32 height; */
  366. NS_IMETHODIMP _MYCLASS_::GetHeight(PRInt32 *aHeight)
  367. {
  368.     return NS_ERROR_NOT_IMPLEMENTED;
  369. }
  370.  
  371. /* [noscript] void getRect (in nsRectRef rect); */
  372. NS_IMETHODIMP _MYCLASS_::GetRect(nsIntRect & rect)
  373. {
  374.     return NS_ERROR_NOT_IMPLEMENTED;
  375. }
  376.  
  377. /* readonly attribute gfx_format format; */
  378. NS_IMETHODIMP _MYCLASS_::GetFormat(gfx_format *aFormat)
  379. {
  380.     return NS_ERROR_NOT_IMPLEMENTED;
  381. }
  382.  
  383. /* readonly attribute boolean needsBackground; */
  384. NS_IMETHODIMP _MYCLASS_::GetNeedsBackground(PRBool *aNeedsBackground)
  385. {
  386.     return NS_ERROR_NOT_IMPLEMENTED;
  387. }
  388.  
  389. /* readonly attribute unsigned long imageBytesPerRow; */
  390. NS_IMETHODIMP _MYCLASS_::GetImageBytesPerRow(PRUint32 *aImageBytesPerRow)
  391. {
  392.     return NS_ERROR_NOT_IMPLEMENTED;
  393. }
  394.  
  395. /* readonly attribute unsigned long imageDataLength; */
  396. NS_IMETHODIMP _MYCLASS_::GetImageDataLength(PRUint32 *aImageDataLength)
  397. {
  398.     return NS_ERROR_NOT_IMPLEMENTED;
  399. }
  400.  
  401. /* void getImageData ([array, size_is (length)] out PRUint8 bits, out unsigned long length); */
  402. NS_IMETHODIMP _MYCLASS_::GetImageData(PRUint8 **bits, PRUint32 *length)
  403. {
  404.     return NS_ERROR_NOT_IMPLEMENTED;
  405. }
  406.  
  407. /* void setImageData ([array, size_is (length), const] in PRUint8 data, in unsigned long length, in long offset); */
  408. NS_IMETHODIMP _MYCLASS_::SetImageData(const PRUint8 *data, PRUint32 length, PRInt32 offset)
  409. {
  410.     return NS_ERROR_NOT_IMPLEMENTED;
  411. }
  412.  
  413. /* void lockImageData (); */
  414. NS_IMETHODIMP _MYCLASS_::LockImageData()
  415. {
  416.     return NS_ERROR_NOT_IMPLEMENTED;
  417. }
  418.  
  419. /* void unlockImageData (); */
  420. NS_IMETHODIMP _MYCLASS_::UnlockImageData()
  421. {
  422.     return NS_ERROR_NOT_IMPLEMENTED;
  423. }
  424.  
  425. /* readonly attribute unsigned long alphaBytesPerRow; */
  426. NS_IMETHODIMP _MYCLASS_::GetAlphaBytesPerRow(PRUint32 *aAlphaBytesPerRow)
  427. {
  428.     return NS_ERROR_NOT_IMPLEMENTED;
  429. }
  430.  
  431. /* readonly attribute unsigned long alphaDataLength; */
  432. NS_IMETHODIMP _MYCLASS_::GetAlphaDataLength(PRUint32 *aAlphaDataLength)
  433. {
  434.     return NS_ERROR_NOT_IMPLEMENTED;
  435. }
  436.  
  437. /* void getAlphaData ([array, size_is (length)] out PRUint8 bits, out unsigned long length); */
  438. NS_IMETHODIMP _MYCLASS_::GetAlphaData(PRUint8 **bits, PRUint32 *length)
  439. {
  440.     return NS_ERROR_NOT_IMPLEMENTED;
  441. }
  442.  
  443. /* void setAlphaData ([array, size_is (length), const] in PRUint8 data, in unsigned long length, in long offset); */
  444. NS_IMETHODIMP _MYCLASS_::SetAlphaData(const PRUint8 *data, PRUint32 length, PRInt32 offset)
  445. {
  446.     return NS_ERROR_NOT_IMPLEMENTED;
  447. }
  448.  
  449. /* void lockAlphaData (); */
  450. NS_IMETHODIMP _MYCLASS_::LockAlphaData()
  451. {
  452.     return NS_ERROR_NOT_IMPLEMENTED;
  453. }
  454.  
  455. /* void unlockAlphaData (); */
  456. NS_IMETHODIMP _MYCLASS_::UnlockAlphaData()
  457. {
  458.     return NS_ERROR_NOT_IMPLEMENTED;
  459. }
  460.  
  461. /* void drawTo (in gfxIImageFrame aDst, in PRInt32 aDX, in PRInt32 aDY, in PRInt32 aDWidth, in PRInt32 aDHeight); */
  462. NS_IMETHODIMP _MYCLASS_::DrawTo(gfxIImageFrame *aDst, PRInt32 aDX, PRInt32 aDY, PRInt32 aDWidth, PRInt32 aDHeight)
  463. {
  464.     return NS_ERROR_NOT_IMPLEMENTED;
  465. }
  466.  
  467. /* attribute long timeout; */
  468. NS_IMETHODIMP _MYCLASS_::GetTimeout(PRInt32 *aTimeout)
  469. {
  470.     return NS_ERROR_NOT_IMPLEMENTED;
  471. }
  472. NS_IMETHODIMP _MYCLASS_::SetTimeout(PRInt32 aTimeout)
  473. {
  474.     return NS_ERROR_NOT_IMPLEMENTED;
  475. }
  476.  
  477. /* attribute long frameDisposalMethod; */
  478. NS_IMETHODIMP _MYCLASS_::GetFrameDisposalMethod(PRInt32 *aFrameDisposalMethod)
  479. {
  480.     return NS_ERROR_NOT_IMPLEMENTED;
  481. }
  482. NS_IMETHODIMP _MYCLASS_::SetFrameDisposalMethod(PRInt32 aFrameDisposalMethod)
  483. {
  484.     return NS_ERROR_NOT_IMPLEMENTED;
  485. }
  486.  
  487. /* attribute gfx_color backgroundColor; */
  488. NS_IMETHODIMP _MYCLASS_::GetBackgroundColor(gfx_color *aBackgroundColor)
  489. {
  490.     return NS_ERROR_NOT_IMPLEMENTED;
  491. }
  492. NS_IMETHODIMP _MYCLASS_::SetBackgroundColor(gfx_color aBackgroundColor)
  493. {
  494.     return NS_ERROR_NOT_IMPLEMENTED;
  495. }
  496.  
  497. /* End of implementation class template. */
  498. #endif
  499.  
  500.  
  501. #endif /* __gen_gfxIImageFrame_h__ */
  502.